home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #2 / Ham Radio 2000 - Volume 2.iso / HAMV2 / TCP_IP / TNOS230S / GPS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-18  |  7.7 KB  |  387 lines
  1. /* GPS port-related user commands
  2.  *   (c) 1993 Brian A. Lantz
  3.  */
  4. #include "global.h"
  5. #ifdef GPS
  6. #include "commands.h"
  7. #include "mbuf.h"
  8. #include "proc.h"
  9. #include "netuser.h"
  10. #include "internet.h"
  11. #include "iface.h"
  12. #ifndef UNIX
  13. #include "n8250.h"
  14. #endif
  15. #include "asy.h"
  16. #ifdef UNIX
  17. #include "unixasy.h"
  18. #endif
  19. #include "gps.h"
  20. #include "files.h"
  21.  
  22. #if !defined(_lint)
  23. static char rcsid[] OPTIONAL = "$Id: gps.c,v 1.20 1997/08/19 01:19:22 root Exp root $";
  24. #endif
  25.  
  26. #define GPSDIAG 1
  27.  
  28. static unsigned short GPStype = 0;
  29. static struct iface *GPSactive = NULLIF;
  30. static struct proc *GPSproc;
  31. static int dev;
  32. static char incoming[1024];
  33. static char fullbuf[GPSMAXLEN];
  34. static char *CmdStr, *InitStr, *TermStr;
  35. #ifdef notyet
  36. static char *TimeStr;
  37. #endif
  38.  
  39. static void GPSrawsend (unsigned char *str, int len);
  40. static char *GPSgetstr (void);
  41. static int dogpsstr (int argc,char *argv[],const char *label, const char *description, char **str);
  42.  
  43. #ifdef GPSDIAG
  44. static void pprintf (const char *str, char *arg);
  45.  
  46. void
  47. pprintf (str, arg)
  48. const char *str;
  49. char *arg;
  50. {
  51.     tcmdprintf (str, arg);
  52.     (void) fflush(stdout);
  53. }
  54. #endif
  55.  
  56. static unsigned char MAG[] = { 0,0,0 };
  57.  
  58. static gpstype Gtypes[] = {
  59.     { 0, (unsigned char *) 0    },    /* Standard */
  60.     { 0, MAG            },    /* Magellan */
  61.     { 0, (unsigned char *) 0    }    /* null */
  62. };
  63.  
  64.  
  65. static void
  66. GPSrawsend (str, len)
  67. unsigned char *str;
  68. int len;
  69. {
  70. #ifdef GPSDIAG
  71.     pprintf("GPSrawsend() reached\n", NULLCHAR);
  72. #endif
  73.     if (!len)
  74.         return;
  75.     (void) asy_send (dev, qdata (str, (int16) len));
  76. }
  77.  
  78.  
  79. static char *
  80. GPSgetstr ()
  81. {
  82. char *cp;
  83. int c;
  84.     
  85.     cp = incoming;
  86.     memset (incoming, 0x20, 1024);
  87.     while((c = get_asy(dev)) != -1){
  88.         *cp++ = ((c == '\r') || (c == 0x0a)) ? ' ' : (char)c;
  89.         if (c == 0x0a)
  90.             break;
  91.     }
  92.     *cp = 0;
  93.     return (strdup (incoming));
  94. }
  95.  
  96.  
  97. static char *
  98. GPSsendstr (char *str)
  99. {
  100. char buf[256];
  101. int response = 1;
  102.  
  103. #ifdef GPSDIAG
  104.     pprintf("GPSsendstr() reached\n", NULLCHAR);
  105. #endif
  106. #ifdef nope
  107.     return (strdup(""));
  108. #else
  109.     if ((GPSactive == NULLIF) || !str || !strlen (str))
  110.         return (strdup (""));
  111.     if (*str == '-')    {
  112.         response = 0;
  113.         str++;
  114.     }
  115. #ifdef TNOS_68K
  116.     sprintf (buf, "%s\n\l", str);
  117. #else
  118.     sprintf (buf, "%s\r\n", str);
  119. #endif
  120.     GPSrawsend ((unsigned char *)buf, (int) strlen (buf));
  121.     if (!response)
  122.         return (strdup (""));
  123.     return (GPSgetstr());
  124. #endif
  125. }
  126.  
  127.  
  128. #ifdef MSDOS
  129. #pragma warn -rch
  130. #endif
  131.  
  132. /* Start GPS on serial line */
  133. int
  134. GPSstart(argc,argv,p)
  135. int argc OPTIONAL;
  136. char *argv[];
  137. void *p OPTIONAL;
  138. {
  139. register struct iface *ifp;
  140. register struct asy *ap;
  141. char *response, *cp;
  142. #if 0
  143. int (*rawsave)(struct iface *,struct mbuf *);
  144. #endif
  145.  
  146.     if((ifp = if_lookup(argv[1])) == NULLIF){
  147.         tcmdprintf(Badinterface,argv[1]);
  148.         return 1;
  149.     }
  150.     for(dev=0,ap = Asy;dev < ASY_MAX;dev++,ap++)
  151.         if(ap->iface == ifp)
  152.             break;
  153.     if(dev == ASY_MAX){
  154.         tcmdprintf("Interface %s not asy port\n",argv[1]);
  155.         return 1;
  156.     }
  157.     if (GPSactive != NULLIF)    {
  158.         tcmdprintf("GPS session already active on %s\n",GPSactive->name);
  159.         return 1;
  160.     }
  161.     ksignal(Curproc,0);    /* Don't keep the parser waiting */
  162.     chname(Curproc,"GPS tip");
  163.     GPSactive = ifp;
  164.     GPSproc = Curproc;
  165.     tcmdprintf("GPS started on %s\n",argv[1]);
  166.  
  167.     /* Save output handler and temporarily redirect output to null */
  168. #if 0
  169.     rawsave = ifp->raw;
  170. #endif
  171.     ifp->raw = bitbucket;
  172.     /* Suspend packet input drivers */
  173.     suspend(ifp->rxproc);
  174.     GPSrawsend (Gtypes[GPStype].data, Gtypes[GPStype].len);
  175.     free (GPSsendstr (InitStr));
  176. #ifdef GPSDIAG
  177.         pprintf("GPScmd reached\n", NULLCHAR);
  178. #endif
  179. #ifdef GPSDIAG
  180.         pprintf("GPS initialization complete\n", NULLCHAR);
  181. #endif
  182.  
  183.     for(;;) {
  184.         response = GPSgetstr ();
  185. #ifdef GPSDIAG
  186.         pprintf("GPSgetstr response - '%s'\n",response);
  187. #endif
  188.         {
  189.         FILE *fp;
  190.             strcpy (fullbuf, Hostname);
  191.             cp = strchr (fullbuf, '.');
  192.             if (cp)
  193.                 *cp = 0;
  194.             strcat (fullbuf, ": ");
  195.             strcat (fullbuf, response);
  196.             free (response);
  197.             if (CurrentPos)
  198.                 free (CurrentPos);
  199.             CurrentPos = strdup (fullbuf);
  200.             fp = fopen (GPSfile, "a+");    /* no error checking yet */
  201.             if (fp)    {
  202.                 rewind (fp);
  203.                 fwrite (fullbuf, 1, GPSMAXLEN, fp);
  204.                 (void) fclose (fp);
  205.             }
  206.         }
  207.     }
  208. #if 0
  209. #ifdef GPSDIAG
  210.     pprintf("GPS shutting down\n", NULLCHAR);
  211. #endif
  212.     free (GPSsendstr (TermStr));
  213.     GPSactive = NULLIF;
  214.     ifp->raw = rawsave;
  215.     resume(ifp->rxproc);
  216.     return 0;
  217. #endif
  218. }
  219.  
  220. #ifdef MSDOS
  221. #pragma warn .rch
  222. #endif
  223.  
  224. int
  225. GPSstop(argc,argv,p)
  226. int argc OPTIONAL;
  227. char *argv[];
  228. void *p OPTIONAL;
  229. {
  230. struct iface *ifp;
  231.  
  232.     if((ifp = if_lookup(argv[1])) == NULLIF){
  233.         tprintf(Badinterface,argv[1]);
  234.         return 1;
  235.     }
  236.     if ((GPSactive == NULLIF) || GPSactive != ifp)    {
  237.         tprintf ("There is no GPS active on %s!\n", argv[1]);
  238.         return 1;     /* wasn't active anyway */
  239.     }
  240.     alert (GPSproc, -1);
  241.     return 0;
  242. }
  243.  
  244.  
  245. static int
  246. dogpsstr(argc,argv,label,description,str)
  247. int argc;
  248. char *argv[];
  249. const char *label, *description;
  250. char **str;
  251. {
  252.     if(argc > 2) {
  253.             tprintf ("Usage: gps %s \"<gps command string>\"\n", label);
  254.         return 0;
  255.     }
  256.  
  257.     if(argc < 2) {
  258.         if(*str != NULLCHAR)
  259.             tprintf("%s: %s", description, *str);
  260.     }
  261.     else {
  262.         if(*str != NULLCHAR){
  263.             free(*str);
  264.             *str = NULLCHAR;    /* reset the pointer */
  265.         }
  266.         if(!strlen(argv[1]))
  267.             return 0;        /* clearing the buffer */
  268.         *str = mallocw(strlen(argv[1])+5);/* allow for the EOL char */
  269.         strcpy(*str, argv[1]);
  270.         strcat(*str, "\n");        /* add the EOL char */
  271.     }
  272.     return 0;
  273. }
  274.  
  275. static int docmdstring (int argc,char *argv[],void *p); 
  276. static int doinitstring (int argc,char *argv[],void *p); 
  277. static int dosendstring (int argc,char *argv[],void *p);
  278. #ifdef GPSDIAG
  279. static int dosetstring (int argc,char *argv[],void *p);
  280. #endif
  281. static int dotermstring (int argc,char *argv[],void *p);
  282. static int dotype (int argc,char *argv[],void *p);
  283. #ifdef notyet
  284. static int dotimestring (int argc,char *argv[],void *p);
  285. #endif
  286.  
  287. static struct cmds GPScmds[] = {
  288.     { "cmdstring",    docmdstring,    0,    0,    NULLCHAR },
  289.     { "initstring",    doinitstring,    0,    0,    NULLCHAR },
  290.     { "sendstring",    dosendstring,    0,    0,    NULLCHAR },
  291. #ifdef GPSDIAG
  292.     { "setstring",    dosetstring,    0,    0,    NULLCHAR },
  293. #endif
  294.     { "termstring",    dotermstring,    0,    0,    NULLCHAR },
  295. #ifdef notyet
  296.     { "timestring",    dotimestring,    0,    0,    NULLCHAR },
  297. #endif
  298.     { "type",    dotype,        0,    0,    NULLCHAR },
  299.     { NULLCHAR,    NULL,        0,    0,    NULLCHAR }
  300. };
  301.  
  302. int
  303. dogps(argc,argv,p)
  304. int argc;
  305. char *argv[];
  306. void *p;
  307. {
  308.     return subcmd(GPScmds,argc,argv,p);
  309. }
  310.  
  311.  
  312. static int
  313. dotype(argc,argv,p)
  314. int argc;
  315. char *argv[];
  316. void *p OPTIONAL;
  317. {
  318.     return setshort (&GPStype, "GPS manufacturer type:",argc, argv);
  319. }
  320.  
  321.  
  322. static int
  323. docmdstring(argc,argv,p)
  324. int argc;
  325. char *argv[];
  326. void *p OPTIONAL;
  327. {
  328.     return dogpsstr (argc, argv, "cmdstring", "GPS Position Command String", &CmdStr);
  329. }
  330.  
  331. static int
  332. doinitstring(argc,argv,p)
  333. int argc;
  334. char *argv[];
  335. void *p OPTIONAL;
  336. {
  337.     return dogpsstr (argc, argv, "initstring", "GPS Initialization String", &InitStr);
  338. }
  339.  
  340. #ifdef GPSDIAG
  341. static int
  342. dosetstring(argc,argv,p)
  343. int argc;
  344. char *argv[];
  345. void *p OPTIONAL;
  346. {
  347.     return dogpsstr (argc, argv, "setstring", "Current GPS data string", &CurrentPos);
  348. }
  349. #endif
  350.  
  351. static int
  352. dotermstring(argc,argv,p)
  353. int argc;
  354. char *argv[];
  355. void *p OPTIONAL;
  356. {
  357.     return dogpsstr (argc, argv, "termstring", "GPS Termination String", &TermStr);
  358. }
  359.  
  360. #ifdef notyet
  361. static int
  362. dotimestring(argc,argv,p)
  363. int argc;
  364. char *argv[];
  365. void *p;
  366. {
  367.     return dogpsstr (argc, argv, "timestring", "GPS Time String", &TimeStr);
  368. }
  369. #endif
  370.  
  371. static int
  372. dosendstring(argc,argv,p)
  373. int argc OPTIONAL;
  374. char *argv[];
  375. void *p OPTIONAL;
  376. {
  377. char *response;
  378.  
  379.     response = GPSsendstr (argv[1]);
  380.     if (*response)
  381.         tprintf ("GPS Response: %s\n", response);
  382.     free (response);
  383.     return 0;
  384. }
  385.  
  386. #endif
  387.